package com.ddm.controller.web;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.ddm.dto.webDTO.*;
import com.ddm.entity.vxEntity.User;
import com.ddm.mapper.WebAdminMapper;
import com.ddm.result.Result;
import com.ddm.service.webService.WebAdminService;
import com.ddm.service.webService.WebUserService;
import com.ddm.utils.SendMUtil;
import com.ddm.vo.webVo.WebUserVO;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

@Slf4j
@RestController
@RequestMapping("/Web/user")


public class WebUserController {
    @Autowired
    private SendMUtil sendMUtil;

    /**
     * 短信签名（实际应配置在配置文件中）
     */
    @Value("${cx.ali.sms.signName}")
    private String smsSignName;
    /**
     * 验证码短信模板（实际应配置在配置文件中）
     */
    @Value("${cx.ali.sms.templateCode}")
    private String smsTemplateCode;
    /**
     * 通知过期短信模板（实际应配置在配置文件中）
     */
    @Value("${cx.ali.sms.templateCode2}")
    private String smsTemplateCode2;
    /**
     * 通知预告过期短信模板（实际应配置在配置文件中）
     */
    @Value("${cx.ali.sms.templateCode3}")
    private String smsTemplateCode3;

    @Autowired
    private WebUserService userService;
    @Autowired
    private WebAdminService webAdminService;
    @Autowired
    private WebAdminMapper webAdminMapper;

    @PostMapping("/register")
    public Result<String> register( @RequestBody WebRegisterDTO registerDTO) {
        userService.register(registerDTO);
        return Result.success("注册成功");
    }

    @PutMapping("/ResetPassword")
    public Result<String> ReUpdate(@RequestBody WebResetPasswordDTO w) {
       return userService.resetPasswordByVerificationCode(w);

    }

    @PostMapping("/login")
    @ApiOperation("页面登录")
    @JsonFormat(shape = JsonFormat.Shape.STRING)
    public Result<WebUserVO> wxLogin(@RequestBody WebLoginDTO loginDTO) {
        WebUserVO userVo = userService.login(loginDTO);

            return Result.success(userVo);

    }
    /**
     * 页面登录接口（支持验证码校验）
     * @param loginDTO 登录请求参数，包含用户名、密码、验证码等
     * @return 登录结果，成功返回用户信息+Token，失败返回错误提示
     */
    @PostMapping("/WebVlogin")
    @ApiOperation("页面登录（支持验证码校验）")
    public Result<WebUserVO> wxLogin2(@Valid @RequestBody WebLoginDTO loginDTO) {
//        // 1. 验证码校验（已在实例实现）
//        if (loginDTO.getVerificationCode() != null && !loginDTO.getVerificationCode().trim().isEmpty()) {
//            Result<Boolean> verifyResult = sendMUtil.verifyCode(
//                    loginDTO.getPhoneNum(), // 假设 WebLoginDTO 里有 account 字段存手机号/邮箱
//                    loginDTO.getVerificationCode()
//            );
//            if (!verifyResult.isSuccess()) {
//                return Result.error(verifyResult.getMsg());
//            }
//        }

        // 2. 调用业务层登录逻辑
        WebUserVO userVo = userService.login2(loginDTO);

        // 3. 封装并返回结果
        return Result.success(userVo);
    }
    /**
     * 通过用户ID获取用户信息
     *
     * @param userId 用户ID
     * @return 用户信息
     */
    @GetMapping("/info")
    public Result<User> getUserInfo(@RequestParam Integer userId) {
        // 验证用户ID是否有效
        if (userId == null || userId <= 0) {
            return Result.error("无效的用户ID");
        }

        User userInfo = userService.getUserInfoById(userId);
        if (userInfo == null) {
            return Result.error("查找不到该用户信息");
        }
        return Result.success(userInfo);
    }

    /**
     * 更新用户信息
     */
    @PostMapping("/info")
    public Result updateUserInfo(
            @Valid @RequestBody UserUpdateDTO userDTO // 用DTO接收参数，避免直接传实体
    ){
        // 1. 参数校验（通过DTO的注解完成，如@NotNull）
        Long userId = userDTO.getId();
        if (userId == null) {
            return Result.error("用户ID不能为空");
        }

        // 2. 调用Service更新（传入DTO，而非原始User实体）
        boolean success = userService.updateUserInfo(userDTO);
        if (success) {
            User updatedUser = userService.getUserInfoById(userId); // 直接用Long
            return Result.success(updatedUser);
        } else {
            return Result.error("更新失败");
        }
    }

    /**
     * 更新用户头像
     */
    @PostMapping("/avatar")
    public Result updateAvatar(@Valid @RequestBody UpdateAvatarDTO dto) {
        boolean success = userService.updateAvatar(dto.getUserId(), dto.getPhotoUrl());
        if (success) {
            User userInfo = userService.getUserInfoById(dto.getUserId());
            return Result.success(userInfo);
        } else {
            return Result.error("更新头像失败");
        }
    }


    /**
     * 更新密码
     */
    @PostMapping("/password")
    public Result updatePassword(
            @RequestParam String oldPassword,
            @RequestParam String newPassword,
            @RequestParam Integer userId  // 新增：直接接收 userId 参数
    ) {

        // 调用服务层方法，获取包含错误描述的结果
        Result<Boolean> updateResult = userService.updatePassword2(userId, oldPassword, newPassword);
        if (!updateResult.getCode().equals(1)) { // 若失败，直接返回服务层的错误信息
            return Result.error(updateResult.getMsg());
        }

        User userInfo = userService.getUserInfoById(userId);
        if (userInfo == null) {
            String errorMsg = "更新成功，但获取用户信息失败";
            log.error(errorMsg + "，userId:{}", userId);
            return Result.error(errorMsg);
        }
        // 安全处理：清除返回结果中的密码字段
        userInfo.setPassword(null);
        return Result.success(userInfo);
    }
    /**
     * 测试验证码生成接口
     * @return 包含验证码信息的结果
     */
    @GetMapping("/t")
    public Result<String> testVerifyCode() {
        return sendMUtil.test(); // 调用你前面的test()方法
    }
    /**
     * 发送验证码
     * 支持短信(1)和邮箱(2)两种方式
     */
    @PostMapping("/send-code")
    @ApiOperation(value = "发送验证码", notes = "verifyType:1-短信,2-邮箱;account:手机号或邮箱地址")
    public Result<String> sendVerificationCode(@Valid @RequestBody WebLoginDTO loginDTO) {
        // 参数校验
        if (loginDTO.getVerifyType() == null) {
            return Result.error("验证类型不能为空");
        }
        if (loginDTO.getPhoneNum() == null || loginDTO.getPhoneNum().trim().isEmpty()) {
            return Result.error("账号（手机号/邮箱）不能为空");
        }

        // 根据验证类型处理
        if (1 == loginDTO.getVerifyType()) {
            // 短信验证
            return sendSmsVerificationCode(loginDTO.getPhoneNum());
        } else if (2 == loginDTO.getVerifyType()) {
            // 邮箱验证（预留实现）
            return sendEmailVerificationCode(loginDTO.getEmail());
        } else {
            return Result.error("不支持的验证类型，请选择1(短信)或2(邮箱)");
        }
    }

    /**
     * 发送短信验证码
     */
    private Result<String> sendSmsVerificationCode(String phoneNumber) {
        try {
            // 简单的手机号格式校验
            if (!sendMUtil.isValidPhoneNumber(phoneNumber)) {
                log.info("手机号格式错误：{}", phoneNumber);
                return Result.error("请输入有效的手机号");
            }

            // 调用短信工具类发送验证码
            return sendMUtil.sendVerifyCode(smsSignName, smsTemplateCode, phoneNumber);

        } catch (Exception e) {
            return Result.error("短信验证码发送失败：" + e.getMessage());
        }
    }

    /**
     * 发送邮箱验证码（预留实现）
     */
    private Result<String> sendEmailVerificationCode(String email) {
        try {
            // 简单的邮箱格式校验
            if (!isValidEmail(email)) {
                return Result.error("请输入有效的邮箱地址");
            }

            // TODO: 实现邮箱验证码发送逻辑
            return Result.success("邮箱验证码已发送，请注意查收（模拟）");
        } catch (Exception e) {
            return Result.error("邮箱验证码发送失败：" + e.getMessage());
        }
    }

//    /**
//     * 手机号格式简单校验
//     */
//    private boolean isValidPhoneNumber(String phone) {
//        // 简单校验中国大陆手机号格式
//        return phone != null && phone.matches("^1[3-9]\\d{9}$");
//    }

    /**
     * 邮箱格式简单校验
     */
    private boolean isValidEmail(String email) {
        if (email == null) {
            return false;
        }
        // 简单的邮箱格式正则
        String regex = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
        return email.matches(regex);
    }

    @GetMapping("/listAdmin")
    @ApiOperation(value = "获取所有管理员列表")
    public Result<List<User>> findAllAdmins() {
        log.info("查询所有管理员");
        List<User> admins = webAdminService.findAllAdmins();
        return Result.success(admins);
    }

    @GetMapping("/findAdminById")
    public Result<User> findAdminById(Long id) {
        log.info("根据ID获取管理员: {}", id);
        // 根据ID查询管理员信息
        User admin = webAdminService.findAdminById(id);
        if (admin == null) {
            // 如果查询结果为null，返回失败结果
            return Result.error("未找到对应的管理员");
        }
        // 直接返回查询到的admin对象，不做任何额外处理
        log.info("根据ID获取管理员信息: {}", admin);
        return Result.success(admin);
    }


    /**
     * 修改用户delete字段（逻辑删除）
     * @param id 用户ID
     * @return 操作结果
     */
    @PostMapping("/updateDelete/{id}")
    public Result<String> updateDelete(@PathVariable("id") Long id) {
        log.info("修改用户delete字段，用户ID：{}",id);
        // 1. 验证用户是否存在
        User admin = webAdminMapper.selectUserById(id);
        if (admin == null) {
            log.warn("修改delete字段失败，用户不存在，ID：{}",id);
            return Result.error("用户不存在");
        }

        // 2. 调用服务层修改delete字段
        boolean success = webAdminService.updateUserDelete(id);
        if (success) {
            log.info("用户delete字段修改成功，ID: {}", id);
            User upAdmin = webAdminMapper.selectUserById(id);
            return upAdmin.getDeleted()==1?Result.success("冻结用户账号"):Result.success("解冻用户账号");
        }else {
            log.error("用户delete字段修改失败，ID: {}", id);
            return Result.error("修改失败，请重试");
        }
    }

    /**
     * 获取所有用户（包括已删除的记录）
     * 注意：此接口应限制访问权限，避免敏感数据泄露
     */
    @GetMapping("/allUserList")
    @ApiOperation(value = "获取所有用户（含已删除）", notes = "返回系统中所有用户记录，包括已逻辑删除的用户")
    public List<User> getAllUsersWithDeleted() {
        return userService.getAllUsersWithDeleted();
    }
    /**
     * 分页带筛选条件查询用户（包括已删除）
     */
    @PostMapping("/filterUser")
    @ApiOperation(value = "分页带筛选条件查询用户", notes = "分页查询，支持按用户名模糊查询和删除状态筛选，返回包括已删除的记录")
    public IPage<User> getUsersWithFilterPage(
            @ApiParam(value = "页码，默认1") @RequestParam(defaultValue = "1") Integer pageNum,
            @ApiParam(value = "每页条数，默认10") @RequestParam(defaultValue = "10") Integer pageSize,
            @ApiParam(value = "用户名（模糊查询）") @RequestParam(required = false) String userName,
            @ApiParam(value = "删除状态（0：未删除，1：已删除，null：不筛选）") @RequestParam(required = false) Integer deleted) {
        return userService.getAllUsersWithConditionPage(pageNum, pageSize, userName, deleted);
    }
//    @PostMapping("/login")
//    public WebUserVO login(@RequestBody @Valid WebLoginDTO loginDTO) {
//        return userService.login(loginDTO);
//    }

//    @GetMapping("/sendCode")
//    public String sendVerificationCode(
//            @RequestParam String target,
//            @RequestParam Integer type,
//            @RequestParam Integer usageType) {
//        userService.sendVerificationCode(target, type, usageType);
//        return "验证码已发送，请注意查收";
//    }

//    @GetMapping("/profile")
//    public Object getUserProfile(HttpServletRequest request) {
//        return request.getAttribute("currentUser");
//    }

    /**
     * 发送套餐过期方法（测试）
     */
    private Result<String> sendPackageSms(String phoneNumber, String userName, String packageName) {
        try {
            // 简单的手机号格式校验
            if (!sendMUtil.isValidPhoneNumber(phoneNumber)) {
                log.info("手机号格式错误：{}", phoneNumber);
                return Result.error("请输入有效的手机号");
            }

            // 调用短信工具类发送验证码
            return sendMUtil.sendPackageSms(smsSignName, smsTemplateCode2, phoneNumber, userName, packageName);

        } catch (Exception e) {
            return Result.error("短信验证码发送失败：" + e.getMessage());
        }
    }

    /**
     * 发送通知接口（测试）
     *
     */
    @GetMapping("/send-package")

    public Result<String> sendPackage() {

        return sendPackageSms("16698509846", "小明", "vip");
    }

    /**
     * 发送预告过期通知方法（测试）
     */
    private Result<String> sendAdPackageSms(String phoneNumber, String userName, String packageName,String date) {
        try {
            // 简单的手机号格式校验
            if (!sendMUtil.isValidPhoneNumber(phoneNumber)) {
                log.info("手机号格式错误：{}", phoneNumber);
                return Result.error("请输入有效的手机号");
            }

            // 调用短信工具类发送验证码
            return sendMUtil.sendAdPackageSms(smsSignName, smsTemplateCode3, phoneNumber, userName, packageName,date);

        } catch (Exception e) {
            return Result.error("短信验证码发送失败：" + e.getMessage());
        }
    }

    /**
     * 发送通知接口（测试）
     *
     */
    @GetMapping("/send-AdPackage")

    public Result<String> sendAdPackage() {

        return sendAdPackageSms("16698509846", "小明", "vip","7");
    }


}
